#include "BlockQueue.hpp"
#include "Task.hpp"
#include <unistd.h>
#include <ctime>

// 1.int类型

// void* Consumer(void* args)
// {
//     BlockQueue<int>* bq = static_cast<BlockQueue<int>*>(args);
//     while(true)
//     {
//         // 1.获取数据
//         int t;
//         bq->Pop(&t);
//         // 2.处理数据
//         std::cout << "Consumer->" << t << std::endl;
//     }
// }

// void* Productor(void* args)
// {
//     srand(time(nullptr) ^ getpid());
//     BlockQueue<int>* bq = static_cast<BlockQueue<int>*>(args);
//     while(true)
//     {
//         // 1.构建数据/任务
//         int x = rand() % 10 + 1; // [1,10]
//         sleep(1); // 1秒生产一个数据
//         // 2.生产数据
//         bq->Equeue(x);
//         std::cout << "Productor->" << x << std::endl;
//     }
// }

// int main()
// {
//     BlockQueue<int>* bq = new BlockQueue<int>();
//     // 单生产 单消费
//     pthread_t c,p;
//     // 创建线程
//     pthread_create(&c,nullptr,Consumer,bq);
//     pthread_create(&p,nullptr,Productor,bq);

//     // 终止线程
//     pthread_join(c,nullptr);
//     pthread_join(p,nullptr);
//     return 0;
// }

// 2.结构体Task类型

// void *Consumer(void *args)
// {
//     BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
//     while (true)
//     {
//         // 1.获取数据
//         Task t;
//         bq->Pop(&t);
//         // 2.处理数据
//         // t.Excute();
//         t(); // 使用仿函数
//         std::cout << "Consumer->" << t.result() << std::endl;
//     }
// }

// void *Productor(void *args)
// {
//     BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
//     while (true)
//     {
//         // 1.构建数据/任务
//         int x = rand() % 10 + 1; // [1,10]
//         usleep(1000);            // 尽量保证随机数不同
//         int y = rand() % 10 + 1;
//         Task t(x,y);
//         // 2.生产数据
//         bq->Equeue(t);
//         std::cout << "Productor->" << t.debug() << std::endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     BlockQueue<Task> *bq = new BlockQueue<Task>();
//     // 单生产 单消费
//     pthread_t c, p;
//     // 创建线程
//     pthread_create(&c, nullptr, Consumer, bq);
//     pthread_create(&p, nullptr, Productor, bq);

//     // 终止线程
//     pthread_join(c, nullptr);
//     pthread_join(p, nullptr);
//     return 0;
// }


// 3.函数类型
void *Consumer(void *args)
{
    BlockQueue<task_t> *bq = static_cast<BlockQueue<task_t> *>(args);
    while (true)
    {
        // 1.获取数据
        task_t t;
        bq->Pop(&t);
        // 2.处理数据
        t(); // 使用仿函数
    }
}

void *Productor(void *args)
{
    BlockQueue<task_t> *bq = static_cast<BlockQueue<task_t> *>(args);
    while (true)
    {
        // 1.生产数据
        bq->Equeue(Download);
        std::cout << "Productor-> Download" << std::endl;
        sleep(1);
    }
}

// int main()
// {
//     BlockQueue<task_t> *bq = new BlockQueue<task_t>();
//     // 单生产 单消费
//     pthread_t c, p;
//     // 创建线程
//     pthread_create(&c, nullptr, Consumer, bq);
//     pthread_create(&p, nullptr, Productor, bq);

//     // 终止线程
//     pthread_join(c, nullptr);
//     pthread_join(p, nullptr);
//     return 0;
// }

int main()
{
    BlockQueue<task_t> *bq = new BlockQueue<task_t>();
    // 多生产 多消费
    pthread_t c1,c2,p1,p2,p3;
    // 创建线程
    pthread_create(&c1, nullptr, Consumer, bq);
    pthread_create(&c2, nullptr, Consumer, bq);
    pthread_create(&p1, nullptr, Productor, bq);
    pthread_create(&p2, nullptr, Productor, bq);
    pthread_create(&p3, nullptr, Productor, bq);

    // 终止线程
    pthread_join(c1, nullptr);
    pthread_join(c2, nullptr);
    pthread_join(p1, nullptr);
    pthread_join(p2, nullptr);
    pthread_join(p3, nullptr);
    return 0;
}